/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package investigaciones_itm.Presupuestos;

import com.sun.rave.web.ui.appbase.AbstractPageBean;
import itm.bo.presupuestos.PresupuestosBO;
import itm.exception.PresupuestoException;
import itm.vo.presupuestos.ComponenteVO;
import itm.vo.presupuestos.fuenteRubroVO;
import itm.vo.presupuestos.rubroProyectoVO;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.component.html.HtmlSelectOneMenu;
import  javax.faces.component.html.HtmlInputText;
import javax.faces.event.ActionEvent;
import javax.faces.event.ValueChangeEvent;
import javax.faces.model.SelectItem;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Map;
import javax.faces.component.UIParameter;
import javax.faces.context.FacesContext;
/**
 *
 * @author jimmy
 */
public class PresupuestoPorConcepto extends AbstractPageBean {

   /*--------------------------------------------- VARIABLES PARA CONTROL DE PRESUPUESTO DE ACUERDO A LA FUENTE*/
    private double douNewVal =  0; //Contiene el nuevo valor asignado a una fuente de un componente
    private double douOldVal =  0; //Contiene el valor anteriormente asignado a una fuente de un componente
    private long   IdProyecto = 2009001; //identificador del proyecto
    private long   idRubro;// Identificador del rubro actual q se esta diligenciando
    private String idfuenteActual;//Identificacion de la fuente  q esta diligenciando
    private long   idComponente;//Identificador del componente actual que se esta diligenciando
    private double totalRubro;//Total asignado por fuentes al rubro
    private double totalDist; //Total distribuido
    private String nombreRubro;
    

    private HtmlSelectOneMenu menu;
    /*--------------------------------------------- LISTADOS */
    private List<rubroProyectoVO> listaRubros = new ArrayList<rubroProyectoVO>();
    /*Almacena el listado de fuentes asociadas al rubro del proyecto que han sido definidos para financiar */
    private List<fuenteRubroVO> listaRubroFuente = new ArrayList<fuenteRubroVO>();
    /*Almacena el listado de conceptos asociadas al rubro del proyecto que han sido definidos para financiar */
    private List<ComponenteVO> lstComponentes = new ArrayList<ComponenteVO>();
    private Hashtable hasFuentes = new Hashtable();
    private List<SelectItem> itemRubros = new ArrayList<SelectItem>();
    private PresupuestosBO presupuestosBO;

    public PresupuestoPorConcepto() {
        inicializar();
    }
    public void inicializar(){
        obtenerRubro();
        this.setTotalRubro(0);
        this.setNombreRubro("--rubro--");
    }

    /*Obtiene el listado de los rubros asignados al proyecto*/
    public void obtenerRubro() {
        presupuestosBO = new PresupuestosBO();
        try {
            listaRubros = presupuestosBO.listaRubroProyecto(IdProyecto);
            for (int i = 0; i < listaRubros.size(); i++) {
                itemRubros.add(new SelectItem(Integer.toString(listaRubros.get(i).getIdRubro()),
                        listaRubros.get(i).getNombreRubro()));
            }
        } catch (Exception ex) {
            Logger.getLogger(PresupuestoPorConcepto.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    /*Ocurre al seleccionar del listado uno de los rubros*/
    public void actionListaRubros(ValueChangeEvent e){
        String sIdRubro = null;
        double iTotalRubro = 0;
        try{
            if(menu!=null){
            sIdRubro = (String) menu.getValue();
            }
            listaRubroFuente = new ArrayList<fuenteRubroVO>();
            this.setIdRubro(Integer.parseInt(sIdRubro));
            presupuestosBO = new PresupuestosBO();
            listaRubroFuente = presupuestosBO.getPresupPorFuenteEstimado(0, IdProyecto, idRubro);
            totalDist = 0;

            for(int i = 0;i<listaRubroFuente.size();i++){
                hasFuentes.put(String.valueOf(listaRubroFuente.get(i).getIdFuenteF()) , listaRubroFuente.get(i));
                iTotalRubro = iTotalRubro + listaRubroFuente.get(i).getValorFuenteF();
            }
            nombreRubro = listaRubroFuente.get(0).getNombreRubro();
            totalRubro =iTotalRubro;
          //  lstComponentes = presupuestosBO.getPresupComponenteEstimado(IdProyecto, idRubro);
            System.out.println("lstComponentes " + lstComponentes.size());
            totalDist  = 0;
            for(ComponenteVO comp: lstComponentes){
                  System.out.println(comp.getNombreComponente());
                   totalDist  =  totalDist + comp.getValorPresupuestado();
            }

        }catch(PresupuestoException ex ){
            error("No fue posible listar las fuentes asociadas al rubro" + ex.getCause().getMessage());
        }
 }

  /**
     Realiza el registro del presupuesto estimado por componente
   */
 public void btnGuardar_action(ActionEvent even){
      System.out.println("btnGuardar_action");
      try{

         if(totalRubro <  totalDist){
             error("El valor presupuestado por componentes es superior al presupuestado" +
                              " a nivel de  fuentes.");
             return;
         }


         if(totalRubro >  totalDist){

           fuenteRubroVO obj ;
           Enumeration efuen = hasFuentes.elements();
            while( efuen.hasMoreElements() ){
                 obj = (fuenteRubroVO)efuen.nextElement() ;
                 if(obj.getValorFuenteF()<obj.getValorPorDistribuir()){
                        error("El valor presupuestado por componente es superior al presupuestado inicialmente" +
                              " para la fuente " + obj.getNombreFuenteExterna()  + ".");
                        return;
                 }
            }
            error("El valor presupuestado por componentes es inferior al presupuestado" +
                              " a nivel de  fuentes.");
            return;
         }
         presupuestosBO = new PresupuestosBO();
         //presupuestosBO.guardarPresupComponenteEstimado(IdProyecto, idRubro,  lstComponentes);
         info("El presupuesto ha sido registrado correctamente.");

      }catch(Exception e){
          e.printStackTrace();
          error("Se presentaron inconvenientes al guardar el producto "+ e.getMessage());
      }
      //return "";
 }

 /*Se produce al realizar algún cambio en las cantidades asignadas*/
 public void controlFuente_action(ValueChangeEvent e){
    try{
        douNewVal =  (Double)e.getNewValue();
        douOldVal =  (Double)e.getOldValue();
        /*  Obtenemos los id correspondientes al componente y la fuente
                del cuadro de texto que se esta modificando
        */
        Map session = FacesContext.getCurrentInstance().getExternalContext().getSessionMap();
        UIParameter parametro = (UIParameter) e.getComponent().findComponent("pcodComponente");
        /*Obtenemos el identificador del componente modificado*/
        idComponente = new Long (parametro.getValue().toString());
        /*Obtenemos el identificador de la fuente modificado*/
        parametro = (UIParameter) e.getComponent().findComponent("pcodFuente");
        System.out.println("7uente.getValue().toString() " +parametro.getValue().toString());
        this.idfuenteActual = parametro.getValue().toString();
        controlFuentes ();
    }catch(Exception ex ){
            error("No fue posible listar las fuentes asociadas al rubro" );
            ex.printStackTrace();
    }
 }


  /****
    Realiza las verificaciones respectivas, para q la distribuci{on no sobre pase
    el monto asignado a cada fuente previamente
   ***/
   public void  controlFuentes (){
      System.out.println("controlFuentes");
     double douValorActual = new Double(douNewVal);
      double douValorCalculado = 0 ;

      if(hasFuentes.containsKey(idfuenteActual)){
            fuenteRubroVO objfuente = (fuenteRubroVO)hasFuentes.get(idfuenteActual);
            System.out.println("*********************************" );
            System.out.println("Valor a Distribuir" + objfuente.getValorFuenteF());
            //Valor digitado (+/-) el valor anterior (+) valor q se habia distribuido
            douValorCalculado =  objfuente.getValorPorDistribuir() + douValorActual + (douOldVal*-1);
            System.out.println("Valor calculado" + douValorCalculado);

            if(objfuente.getValorFuenteF() < douValorCalculado  ){
                System.out.println("ERROOOOOOOOOOOOOOOOR");
                error("El valor especificado para la fuente es de "+ objfuente.getValorFuenteF()+
                        ".\n. El valor que puede distribuir corresponde a "
                        + (objfuente.getValorFuenteF()- objfuente.getValorPorDistribuir()) );
            }
            objfuente.setValorPorDistribuir(douValorCalculado);
            System.out.println("getValorPorDistribuir" + objfuente.getValorPorDistribuir());
            hasFuentes.remove(idfuenteActual);
            hasFuentes.put(idfuenteActual,objfuente );
            System.out.println("OKKKKKKKKKKKKKKKKKKKKKKKKKKKK");
      
              /*Suma Por componente*/
            System.out.println("Componente param: ");
            System.out.print((String)FacesContext.getCurrentInstance().getExternalContext().
            getRequestParameterMap().get("codComponente"));
            System.out.println("Componente "+ idComponente);
              for(ComponenteVO comp: lstComponentes){
                  System.out.println(comp.getNombreComponente());
                  if(idComponente == comp.getCodigoComponente()) {
                      douValorCalculado =  comp.getValorPresupuestado() 
                              + douValorActual + (douOldVal*-1);
                              comp.setValorPresupuestado(douValorCalculado) ;
                              break;        
                  }
              }
            totalDist = totalDist  + douValorActual + (douOldVal*-1);
            /*Inicializo de nuevo las variable por el 
             * caso de que el change no se detecte por falta de valor*/  
            douOldVal = 0;
            douNewVal = 0;


      }



      //return "";
        
  }

    public double getTotalRubro() {
        return totalRubro;
    }

    public void setTotalRubro(double totalRubro) {
        this.totalRubro = totalRubro;
    }




    public long getIdRubro() {
        return idRubro;
    }

    public void setIdRubro(long idRubro) {
        this.idRubro = idRubro;
    }

    

    public List<rubroProyectoVO> getListaRubros() {
        return listaRubros;
    }

    public void setListaRubros(List<rubroProyectoVO> listaRubros) {
        this.listaRubros = listaRubros;
    }

    public List<SelectItem> getItemRubros() {
        return itemRubros;
    }

    public void setItemRubros(List<SelectItem> itemRubros) {
        this.itemRubros = itemRubros;
    }

    public PresupuestosBO getPresupuestosBO() {
        return presupuestosBO;
    }

    public void setPresupuestosBO(PresupuestosBO presupuestosBO) {
        this.presupuestosBO = presupuestosBO;
    }

    public HtmlSelectOneMenu getMenu() {
        return menu;
    }

    public void setMenu(HtmlSelectOneMenu menu) {
        this.menu = menu;
    }

    public String getNombreRubro() {
        return nombreRubro;
    }

    public void setNombreRubro(String nombreRubro) {
        this.nombreRubro = nombreRubro;
    }

    public List<ComponenteVO> getLstComponentes() {
        return lstComponentes;
    }

    public void setLstComponentes(List<ComponenteVO> lstComponentes) {
        this.lstComponentes = lstComponentes;
    }

    public double getTotalDist() {
        return totalDist;
    }

    public void setTotalDist(double totalDist) {
        this.totalDist = totalDist;
    }
    


    
    
}
